/**
 * @author yangyj
 * @desc core.js核心
 * @depends
 */
(function(window){
    "use strict";
	//如果已经存在vita对象，则不再重复初始化
	var vita = window.vita || {};
	if(vita.version){
		return;
	}
	//类型对象//类型判断用
	var class2type = {} , index = 0 , classes = "Boolean Number String Function Array Date RegExp Object Error".split(" ");
	for(;index < classes.length ; index++){
		class2type["[object " + classes[index] + "]"] = classes[index].toLowerCase();
	}
	//核心方法，不直接对外暴露
	var core = {
		//判断对象类型
		type : function(obj){
			if(typeof obj === "undefined"){
				return "undefined";
			}
			if(obj == null){
				return obj + "";
			}
			// 支持: Android<4.0, iOS<6
			return typeof obj === "object" || typeof obj === "function" ? class2type[Object.prototype.toString.call(obj)] || "object" : typeof obj;
		},
		//扩展、拷贝
		extend : function(){
			var options, name, src, copy, copyIsArray, clone, target = arguments[0] || {}, length = arguments.length,
				deep = false, i = 1;//真实目标对象索引
			// 判断是否深度拷贝
			if(typeof target === "boolean"){
				deep = target;
				target = arguments[1] || {};
				i = 2;// 第一个参数为是否深度拷贝标识，索引后移
			}
			// 如果目标不是对象或者函数，则重置成空对象
			if(typeof target !== "object" && typeof target !== "function"){
				target = {};
			}
			// 如果入参长度和i相等，说明只有一个入参是需要拷贝的对象，直接返回
			if(length === i){
				return arguments[length-1];
			}
			//拷贝
			for(;i < length;i++){
				// 处理非null/undefined的入参
				if((options = arguments[i]) != null){
					for (name in options) {
						src = target[name];
						copy = options[name];
						if(target === copy){
							continue;
						}
						// 如果是对象或者数组，需要递归
						if(deep && copy && (core.isPlainObject(copy) || (copyIsArray = core.isArray(copy)))){
							if(copyIsArray){
								copyIsArray = false;
								clone = src && core.isArray(src) ? src : [];
							}else{
								clone = src && core.isPlainObject(src) ? src : {};
							}
							target[name] = core.extend(deep, clone, copy);
						}else if(copy !== undefined){
							target[name] = copy;
						}
					}
				}
			}
			return target;
		},
		//是否原生对象
		isPlainObject: function(obj) {
			if(!obj || core.type(obj) !== "object" || obj.nodeType || core.isWindow(obj)){
				return false;
			}
			try{
				//原生object构造函数
				if(obj.constructor && !hasOwnProperty.call(obj, "constructor") && !hasOwnProperty.call(obj.constructor.prototype, "isPrototypeOf")){
					return false;
				}
			}catch(e){
				return false;
			}
			var key;
			for(key in obj){}//判断obj是否是空对象
			return key === undefined || hasOwnProperty.call(obj, key);
		},
		//是否函数
		isFunction : function(obj){
			return core.type(obj) === "function";
		},
		//是否数组
		isArray : Array.isArray || function(obj){
			return core.type(obj) === "array";
		},
		//是否字符串
		isString : function(obj){
			return core.type(obj) === "string";
		},
		//是否对象
		isObject : function(obj){
			return core.type(obj) === "object";
		},
		//是否数字
		isNumber : function(e) {
			return typeof e === "number" && isFinite(e)
		},
		//是否声明
		isDefined : function(obj) {
			return core.type(obj) !== "undefined";
		},
		//是否window对象
		isWindow : function(obj) {
			return obj != null && obj == obj.window;
		},
		//是否dom对象
		isDomObj : function(obj){
			return obj ? !!obj.nodeType : false;//scopeName在火狐下木有这个属性，所以用nodeType来判断
		},
		//是否jquery对象
		isJQueryObj : function(obj){
			return obj ? !!obj.jquery : false;
		}
	};
	//初始化vita对象
	vita = {
		//版本//只读
		// get version(){
        //    return "0.2.1";
        // },
        version : "0.2.1",
		//大名//只读
		// get name(){
        //    return "vita";
        // },
        name : "vita",
		//唯一对外的方法
		self : function(){
			if(arguments && arguments.length > 0){
				var handle = arguments[0], params = Array.prototype.slice.call(arguments,1);
				if(core.type(core[handle]) === "function"){
					//如果是函数
					return core[handle].apply(vita,params);
				}else{
					//否则当作属性返回
					return core[handle];
				}
			}
			return vita;//没有入参就返回vita对象
		},
		//空函数
		noop : function(){},
		//常量：重定向
		// get REDIRECT(){
		// 	return "webAssist.redirect";
		// },
        REDIRECT : "webAssist.redirect",
		//失去焦点//流程上表现为回到上级流程
		// get OUT_OF_FOCUS(){
		// 	return "outOfFocus";
		// },
        OUT_OF_FOCUS : "outOfFocus",
		//常量：中断
		// get INTERRUPT(){
		// 	return "aop.interrupt";
		// }
        INTERRUPT : "aop.interrupt"
	};
	for(var i in core){
		vita[i] = core[i];
	}
	//通知window对象
	window.vita = vita;
})(window);

/**
 * @author yangyj
 * @desc queue.js 队列
 * @depends core.js
 */
(function(window){
    "use strict";
    //如果vita为空，或者vita下已经生成queues节点，则不再重复初始化
	var vita = window.vita;
	if (!vita || vita.queues){
		return;
	}
	//队列实例//cache = { queueName1 : queue<message> , queueName2 : queue<message> }
	var cache = {};
    //不公开的队列方法（增删查）
    var queues = {
        //创建队列
        create : function(name){
            if(cache[name]){
                throw new Error("命名为" + name + "的队列已经被创建，不能重复创建！");
                return false;
            }
            var q = new queue(name);
            cache[name] = q;
            return q;
        },
        //删除队列
        delete : function(name){
            if(cache[name]){
                delete cache[name];
            }
        },
        //获取队列
        get : function(name){
            return cache[name];
        }
    };
	//初始化队列queues
	vita.queues = {
        //直接生产
        produce : function(name,msg,handler,params){
            var q = queues.get(name);
            if(!q){
                q = queues.create(name);
            }
            return q.produce(msg,handler,params);
        },
        //直接消费
        consume : function(name){
            var q = queues.get(name) , re = null;
            if(q){
                re = q.consume();
            }
            return re;
        },
        //直接消费全部
        consumeAll : function(name){
            var q = queues.get(name);
            if(q){
                q.consumeAll();
            }
        },
        //调用隐藏方法用
        self : function(){
            if(arguments && arguments.length > 0){
                var handle = arguments[0], params = Array.prototype.slice.call(arguments,1);
                if(vita.self("type",queues[handle]) === "function"){
                    //如果是函数
                    return queues[handle].apply(vita.queues,params);
                }else{
                    //否则当作属性返回
                    return queues[handle];
                }
            }
            return vita.queues;//没有入参就返回vita.queues对象
        }
	};
    
    //队列类
    var queue = function(name){
        this.name = name;
        this.messages = [];
    };
    queue.prototype = {
        //生产消费到队列，返回队列长度
        produce : function(msg,handler,params){
            var m = new message(msg,handler,params);
            this.messages.push(m);
            return this.messages.length;
        },
        //消费队列里的消息，如果是function则执行并返回结果，否则直接返回消息
        consume : function(){
            if(this.messages.length == 0){
                return null;
            }
            var data = this.messages.shift();
            return data.handle();
        },
        //消费队列里的全部数据
        consumeAll : function(){
            while(this.messages.length > 0){
                this.consume();
            }
        }
    };
    
    //消息类，第一个入参是消息体，第二个是句柄，不需要则送null，如果没有第三个参数，可以不送，第三个入参作为送入消息体的参数
    var message = function(msg,handler,params){
        this.message = msg;
        this.handler = handler;
        this.datas = [];
        if(params){
            if(vita.self("isArray",params)){
                this.datas = this.datas.concat(params);
            }else{
                this.datas.push(params);
            }
        }
    };
    message.prototype = {
        //消息处理
        handle : function(){
            var re = this.message;
            //如果是函数，返回函数的执行结果
            if(vita.self("isFunction",re)){
                var handler = this.handler;
                if(!handler){
                    handler = vita.queues;
                }
                re = re.apply(handler,this.datas);
            }
            return re;
        }
    };
})(window);
/**
 * @author yangyj
 * @desc event.js 事件
 * @depends core.js, queue.js, jquery.js
 */
(function(window){
    "use strict";
	//如果vita为空，或者vita下已经生成event节点，则不再重复初始化
	var vita = window.vita;
	if (!vita || vita.event){
		return;
	}
	//事件缓存//cache = { eventName : [{ target:widget1,func:func1 } , { target:widget2,func:func2 }] }
	var cache = {};
	//不公开的事件方法
	var event = {
		//获取事件侦听
		getListeners : function(widget,eventName){
			var tars, re = {}, index, subIndex;
			//无入参时，返回所有事件
			if(arguments.length == 0){
				re = cache;
			}else
			//只有一个入参时，且入参是string，判定为事件名
			if(arguments.length == 1 && vita.self("type",arguments[0]) === "string"){
				var eName = arguments[0];
				re[eName] = cache[eName];
			}else
			//只有一个入参时，且入参是对象，判定为目标对象
			if(arguments.length == 1 && vita.self("type",arguments[0]) === "object"){
				var tObj = arguments[0];
				for(index in cache){
					var event = cache[index] , obj = [];
					for(subIndex in event){
						var tar = event[subIndex];
						if(tar.target === tObj){
							obj.push(tar);
						}
					}
					if(obj.length > 0){
						re[index] = obj;
					}
				}
			}else
			//如果有2个及以上入参，正常处理
			if(arguments.length >= 2){
				//只取前两个参数
				tars = cache[eventName];
				for(index in tars){
					var obj = [];
					if(tars[index].target === widget){
						obj.push(tars);
					}
					if(obj.length > 0){
						re[index] = obj;
					}
				}
			}
			return re;
		}
	};
	//初始化事件
	vita.event = {
		//添加事件侦听
		addListener : function(widget,eventName,func){
			//给指定对象增加事件侦听
			var add = function(widget,eventName,func){
				var tarObj = {
					target : widget,
					func : func
				};
				if(!cache[eventName]){
					cache[eventName] = [tarObj];
				}else{
					cache[eventName].push(tarObj);
				}
			};

			if(vita.self("isJQueryObj", widget)){
				//如果是jquery对象，拆开，一般用来html的dom对象
				for(var index = 0;index < widget.length;index++){
					add(widget[index], eventName, func);
				}
			}else{
				add(widget, eventName, func);
			}
		},
		//删除事件侦听
		removeListener : function(widget,eventName,func){
			var events , re = [] , index, subIndex, needToDel = [];
			if(arguments.length == 1){
				//只有一个入参时
				var arg = arguments[0];
				if(vita.self("type",arg) === "string"){
					//判断为只有事件名
					delete cache[arg];
				}else if(vita.self("type",arg) === "object"){
					//判断为只有对象
					for(index in cache){
						events = cache[index], needToDel = [];
						for(subIndex in events){
							if(events[subIndex].target === arg){
								//记录需要删除值的索引
								needToDel.unshift(subIndex);
							}
						}
						for(subIndex in needToDel){
							//从数组中删除值
							events.splice(needToDel[subIndex],1);
						}
					}
				}else if(vita.self("type",arg) === "function"){
					//判断为只有事件体（方法）
					for(index in cache){
						events = cache[index], needToDel = [];
						for(subIndex in events){
							if(events[subIndex].func === arg){
								//记录需要删除值的索引
								needToDel.unshift(subIndex);
							}
						}
						for(subIndex in needToDel){
							//从数组中删除值
							events.splice(needToDel[subIndex],1);
						}
					}
				}
			}else if(arguments.length == 2){
				//只有两个入参时
				var arg0 = arguments[0], arg1 = arguments[1];
				if(vita.self("type",arg0) === "object" && vita.self("type",arg1) === "string"){
					//指定对象和事件名
					events = cache[arg1];
					for(index in events){
						if(events[index].target === arg0){
							//记录需要删除值的索引
							needToDel.unshift(index);
						}
					}
					for(index in needToDel){
						//从数组中删除值
						events.splice(needToDel[index],1);
					}
				}else if(vita.self("type",arg0) === "object" && vita.self("type",arg1) === "function"){
					//指定对象和函数
					for(index in cache){
						events = cache[index], needToDel = [];
						for(subIndex in events){
							if(events[subIndex].target === arg0 && events[subIndex].func === arg1){
								//记录需要删除值的索引
								needToDel.unshift(subIndex);
							}
						}
						for(subIndex in needToDel){
							//从数组中删除值
							events.splice(needToDel[subIndex],1);
						}
					}
				}else if(vita.self("type",arg0) === "string" && vita.self("type",arg1) === "function"){
					//指定事件名和函数
					events = cache[arg0];
					for(index in events){
						if(events[index].func === arg1){
							//记录需要删除值的索引
							needToDel.unshift(index);
						}
					}
					for(index in needToDel){
						//从数组中删除值
						events.splice(needToDel[index],1);
					}
				}
			}else if(arguments.length >= 3){
				//超过三个入参，只取前三个
				events = cache[eventName];
				for(index in events){
					if(events[index].target === widget && events[index].func === func){
						//记录需要删除值的索引
						needToDel.unshift(index);
					}
				}
				for(index in needToDel){
					//从数组中删除值
					events.splice(needToDel[index],1);
				}
			}
		},
		//派发事件
		dispatchEvent : function(param1, param2){
			if(arguments.length == 0){
				//没有入参，返回
				return false;
			}
            var widget = param1, eventName = param2, paramStart = 2;
			if(typeof widget === "string"){
				if(widget.indexOf("#") > -1 || widget.indexOf("vita.") > -1){
					//widget以#或者vita.开头的时候，如果eventName不是字符串，则判定错误
					if(typeof eventName !== "string"){
						return false;
					}else if(!cache[eventName]){
						//如果不存在事件，返回
						return false;
					}
					if(widget.indexOf("#") > -1){
						//id
						widget = widget.substring(1).split(",");
						for(var i = 0;i < widget.length;i++){
							widget[i] = document.getElementById(widget[i]);
						}
					}else if(widget.indexOf("vita.") > -1){
						//vita组件
						widget = widget.substring(5).split(",");
						for(var i = 0;i < widget.length;i++){
							widget[i] = $("[data-widgetfullname=vita-" + widget[i] + "]");
						}
					}
				}else{
					if(!cache[widget]){
						//如果不存在事件，返回
						return false;
					}else{
						eventName = widget;
						widget = null;
						//第一个入参是字符串，参数前移一位
						paramStart = 1;
					}
				}
			}
			if(!cache[eventName]){
				//如果不存在事件，返回
				return false;
			}
			if(widget && !vita.self("isArray", widget)){
				widget = [widget];
			}
			//获取事件列表
			var events = cache[eventName] , event , index = 0;
			for(;index < events.length;index++){
				event = events[index];
				if(widget){
					for(var x = 0;x < widget.length;x++){
						if(event.target.getElement() === widget[x][0] || event.target.getElement()[0] === widget[x][0]){
							vita.queues.produce("vita.event." + eventName, event.func, event.target, Array.prototype.slice.call( arguments, paramStart ));
						}
					}
				}else{
					vita.queues.produce("vita.event." + eventName, event.func, event.target, Array.prototype.slice.call( arguments, paramStart ));
				}
			}
			vita.queues.consumeAll("vita.event." + eventName);
		},
		//用来调用不公开的方法，主要调试查问题时使用
		self : function(){
			if(arguments && arguments.length > 0){
				var handle = arguments[0], params = Array.prototype.slice.call(arguments,1);
				if(vita.self("type",event[handle]) === "function"){
					//如果是函数
					return event[handle].apply(vita.event,params);
				}else{
					//否则当作属性返回
					return event[handle];
				}
			}
			return vita.event;//没有入参就返回vita.event对象
		}
	};
})(window);
/**
 * @author yangyj
 * @desc aop.js 切面
 * @depends core.js
 */
(function(window){
    "use strict";
    //如果vita为空，或者vita下已经生成aop节点，则不再初始化
    var vita = window.vita;
    if (!vita || vita.aop){
        return;
    }
    //不公开的切面方法
    var aop = {
        //组织
        weave : function(type, pointcut, advice, namespaces){
            var aspect, method, funs;
            if(vita.self("isFunction", pointcut)){
                //pointcut是函数时，不直接替换，将返回处理后的函数
                method = pointcut;
            }else if(vita.self("isString", pointcut)){
                if(vita.self("isJQueryObj",namespaces)){
                    //jquery对象，按dom的方式组织
                    return aop.weaveDom(type, pointcut, advice, namespaces[0]);
                }else if(vita.self("isDomObj",namespaces)){
                    //dom对象，按dom的方式组织
                    return aop.weaveDom(type, pointcut, advice, namespaces);
                }
                //解析pointcut
                funs = aop.analyze(pointcut, namespaces);
                method = funs[0][funs[1]];
                if(!vita.self("isFunction", method)){
                    throw new Error("vita.aop 异常 : 入参不符合要求");
                }
            }else{
                throw new Error("vita.aop 异常 : 入参不符合要求");
            }
            //开始aop处理
            switch (type){
                case "_before" :
                    aspect = function(){
                        var re = advice.apply(this,arguments);
                        if(re != vita.INTERRUPT){
                            return method.apply(this,arguments);
                        }
                    };
                    break;
                case "_after" :
                    aspect = function(){
                        var re = method.apply(this,arguments);
                        if(re != vita.INTERRUPT){
                            advice.apply(this,arguments);
                        }
                        return re;
                    };
                    break;
                case "_around" :
                    aspect = function(){
                        var reBe = advice.apply(this,arguments);
                        if(reBe != vita.INTERRUPT){
                            var re = method.apply(this,arguments);
                            if(re != vita.INTERRUPT){
                                advice.apply(this,arguments);
                            }
                            return re;
                        }
                    };
                    break;
            };
            if(aspect){
                //恢复原状的方法
                aspect.__restore = function(){
                    if(funs){
                        funs[0][funs[1]] = method;
                        aspect = method = null;//释放
                    }else{
                        aspect = null;
                        return method;
                    }
                };
                if(funs){
                    //原函数替换成修改后的函数
                    funs[0][funs[1]] = aspect;
                }
            }
            return aspect;
        },
        //dom
        weaveDom : function(type, pointcut, advice, namespaces){
            var _method = function(e){
                if(namespaces == e.target || $(namespaces).find(e.target).length > 0){
                    //只要目标是指定对象时才能触发
                    advice.apply(namespaces,arguments);
                }
            };
            switch (type){
                case "_before" :
                    namespaces.parentNode.addEventListener(pointcut,_method,true);
                    aop.addDomRestore(pointcut, namespaces, function(){
                        namespaces.parentNode.removeEventListener(pointcut,_method,true);
                    });
                    break;
                case "_after" :
                    namespaces.parentNode.addEventListener(pointcut,_method,false);
                    aop.addDomRestore(pointcut, namespaces, function(){
                        namespaces.parentNode.removeEventListener(pointcut,_method,false);
                    });
                    break;
                case "_around" :
                    namespaces.parentNode.addEventListener(pointcut,_method,true);
                    namespaces.parentNode.addEventListener(pointcut,_method,false);
                    aop.addDomRestore(pointcut, namespaces, function(){
                        namespaces.parentNode.removeEventListener(pointcut,_method,true);
                        namespaces.parentNode.removeEventListener(pointcut,_method,false);
                    });
                    break;
            };
            return true;
        },
        //恢复
        restore : function (pointcut, namespaces) {
            var re;
            if(vita.self("isFunction", pointcut)){
                //如果pointcut是函数
                re = pointcut.__restore ? pointcut.__restore() : null;
                delete pointcut.__restore;
                return re;
            }else if(vita.self("isString", pointcut)){
                if(vita.self("isJQueryObj",namespaces)){
                    namespaces = namespaces[0];
                    if(namespaces.__restore && namespaces.__restore[pointcut]){
                        re = namespaces.__restore[pointcut]();
                        delete namespaces.__restore[pointcut];
                    }
                    return  re;
                }else if(vita.self("isDomObj",namespaces)){
                    if(namespaces.__restore && namespaces.__restore[pointcut]){
                        re = namespaces.__restore[pointcut]();
                        delete namespaces.__restore[pointcut];
                    }
                    return  re;
                }else {
                    var funcs = aop.analyze(pointcut, namespaces), m = funcs[0][funcs[1]];
                    re = m.__restore ? m.__restore() : null;
                    delete m.__restore;
                    return re;
                }
            }else{
                throw new Error("vita.aop 异常 : 入参不符合要求");
            }
        },
        //添加dom的恢复方法
        addDomRestore : function (pointcut, namespaces, func) {
            if(!namespaces.__restore){
                namespaces.__restore = {};
            }
            namespaces.__restore[pointcut] = func;
        },
        //解析目标
        analyze : function (pointcut, namespaces) {
            if(!namespaces){
                namespaces = window;
            }
            var ps = pointcut.split("."), l = ps.length, re = [];
            for(var i = 0; i < l; i++){
                if(i == l - 1){
                    re.push(namespaces);
                    re.push(ps[i]);
                }else {
                    namespaces = namespaces[ps[i]];
                }
            }
            return re;
        }
    };
    //
    vita.aop = {
        before : function(pointcut, advice, namespaces) {
            return aop.weave("_before", pointcut, advice, namespaces);
        },
        after : function(pointcut, advice, namespaces) {
            return aop.weave("_after", pointcut, advice, namespaces);
        },
        around : function(pointcut, advice, namespaces) {
            return aop.weave("_around", pointcut, advice, namespaces);
        },
        restore : function (pointcut, namespaces) {
            return aop.restore(pointcut, namespaces);
        }
    };
})(window);
/**
 * @author yangyj
 * @desc ajax.js
 * @depends core.js, jquery.js
 */
(function(window){
    "use strict";
    //如果vita为空，或者vita下已经生成ajax节点，则不再重复初始化
    var vita = window.vita;
    if (!vita || vita.ajax){
        return;
    }
    var $ = window.jQuery, defaultOptions = {
        timeout : 1000 * 60,
        beforeSend : function(xhr){},
        error : function(xhr,statusText,error){
            switch (xhr.status){
                case 404 : local.for404(xhr,statusText,error);break;
                case 500 : local.for500(xhr,statusText,error);break;
                default : ;
            }
        },
        success : function(data,statusText,xhr){},
        complete : function(xhr,ts){}
    };
    /**
     * vita.ajax
     * @param url 请求地址
     * @param params 请求参数
     * @param callBack 回调函数
     * @param options 选项
     * {
     *      type : "GET"、"POST"     请求方式，默认为"GET"
     *      async : true  false     默认值: true。默认设置下，所有请求均为异步请求
     *      context :               回调函数上下文，默认送给ajax的options
     *      dataType :              预期服务器返回的数据类型。如果不指定，jQuery 将自动根据 HTTP 包 MIME 信息来智能判断
     *      timeout :               超时时间（毫秒）
     * }
     */
    vita.ajax = function(url, params, callBack, options){
        var ops = $.extend(true, {}, defaultOptions);
        //入参整理
        if(typeof params === "function"){
            //params是函数，则判定没有参数
            options = callBack;
            callBack = params;
            params = null;
        }else if(typeof params === "object"){
            ops.type = "POST";
        }else{
            params = null;
        }
        if(callBack && typeof callBack !== "function"){
            options = callBack;
            callBack = vita.noop;
        }
        if(typeof options !== "object"){
            options = {};
        }
        //最终的选项
        $.extend(ops, options, {
            url : url,
            data : params,
            success : callBack
        });
        if(options.mask == true){
            var loading = vita.widget.require("loading");
            ops.beforeSend = function(){
                loading.open();
            };
            ops.complete = function(){
                loading.close();
            };
        }
        //调用jquery的ajax
        return $.ajax(ops);
    };
    //界面加载
    vita.load = function(target, url, params, callBack, options){
        if(!vita.self("isJQueryObj", target)){
            target = $(target);
        }
        if(!$.isFunction(callBack)){
            options = callBack;
            callBack = $.noop;
        }
        if(typeof options !== "object"){
            options = {};
        }
        $.extend(options, {dataType : "html"});
        vita.ajax(url, params, options)
            .done(function(responseText){
                var re = $(responseText);
                //回调函数
                if($.isFunction(callBack)){
                    callBack.call(vita, re);
                }
                target.html(re);
            })
            .complete($.isFunction(options.complete) ? options.complete : $.noop);
    };

    var local = {
        for404 : function(xhr,statusText,error){
            var dialog = vita.widget.require("dialog");
            dialog.new({
                title : "发生异常：404",
                content : xhr.responseText,
                buttons : {
                    text : "我知道了"
                }
            }).getElement().appendTo("body");
        },
        for500 : function(xhr,statusText,error){
            var dialog = vita.widget.require("dialog");
            dialog.new({
                title : "发生异常：500",
                content : xhr.responseText,
                buttons : {
                    text : "我知道了"
                }
            }).getElement().appendTo("body");
        }
    };
})(window);
/**
 * @author yangyj
 * @desc router.js 路由
 * @depends core.js
 */
(function(window, location){
    "use strict";
    //如果vita为空，或者vita下已经生成router节点，则不再重复初始化
    var vita = window.vita;
    if (!vita || vita.router){
        return;
    }

    //window的hashchange事件，兼容ie8
    var addEventListener = window.addEventListener || function(eventName, listener) {
            return attachEvent('on' + eventName, listener);
        };

    addEventListener("hashchange", function(e){
        var event = e || window.event, isKeep = false;
        if(event){
            var newHash = router.getHash(window), oldHash;
            if(router.positive == true){
                //重定向
                oldHash = router.oldHash;
                if(router.history.length > 0 && router.historyIndex + 1 < router.history.length){
                    router.history.length = router.historyIndex + 1;
                }
                router.history.push(newHash);
                router.historyIndex++;
            }else{
                if(newHash == router.history[router.historyIndex - 1]){
                    //判断为触发了返回
                    oldHash = router.history[router.historyIndex];
                    router.historyIndex--;
                    if(router.limitCount > 0){
                        //禁止router
                        if(!router.fromLimit){
                            router.fromLimit = true;
                            history.forward();
                        }else{
                            router.fromLimit = false;
                        }
                        return false;
                    }
                    router.positive = "back";
                }else{
                    if(newHash == router.history[router.historyIndex + 1]){
                        //判断为触发了前进
                        oldHash = router.history[router.historyIndex];
                        router.historyIndex++;
                        if(router.limitCount > 0){
                            //禁止router
                            if(!router.fromLimit){
                                router.fromLimit = true;
                                history.back();
                            }else{
                                router.fromLimit = false;
                            }
                            return false;
                        }
                        router.positive = "forward";
                    }else{
                        //锚点不符合要求
                        alert("锚点不符合要求，待处理");
                    }
                }
            }
            if(router.namespaces && router.advice){
                var re = router.namespaces[router.advice](newHash, oldHash);
                switch (re){
                    case "back" : history.back();break;
                    case "forward" : history.forward();break;
                    case vita.REDIRECT : isKeep = true;break;
                }
            }
        }
        if(!isKeep){
            router.positive = false;
        }
    }, false);

    var router = {
        history : [],
        historyIndex : -1,
        oldHash : null,
        newHash : null,
        namespaces : null,
        advice : null,
        positive : false,
        limitCount : 0,
        getHash : function(window){
            var match = window.location.href.match(/#(.*)$/);
            return match ? match[1] : '';
        }
    };

    vita.router = {
        init : function(namespaces, advice){
            router.namespaces = namespaces;
            router.advice = advice;
        },
        navigate : function(hash){
            router.oldHash = router.getHash(window);
            router.newHash = hash;
            router.positive = true;
            location.hash = "#" + hash;
        },
        // get positive(){
        //     return router.positive;
        // },
        getPositive : function(){
            return router.positive;
        },
        addLimit : function(){
            router.limitCount++;
        },
        delLimit : function(){
            router.limitCount--;
        }
    };

})(window, window.location);
/**
 * @author yangyj
 * @desc widget.base.js 基本组件类
 * @depends core.js, event.js
 */
(function(window){
    "use strict";
	//如果vita为空，或者vita下已经生成Widget节点，则不再初始化
	var vita = window.vita;
	if (!vita || vita.Widget){
		return;
	}
	//基类
	vita.Widget = function(){};
	vita.Widget.prototype = {
        //是否含有元素
        // get hasElement(){
        //     return !!this.element;
        // },
        hasElement : function () {
            return !!this.element;
        },
        //单例模式
        // get singleton(){
        //     return true;
        // },
        singleton : true,
		//选项//参数
		options : {},
		//创建widget
		_createWidget : function(options){
			//选项合并
			this.options = vita.self("extend", true, {}, this.options, options);
			//全局引用
			this.global = vita.self("extend", true, {}, this.global);
			//初始化
			this._init();
			//插件初始化完成
			this.isComplete = true;
		},
		//初始化插件//让插件自行实现
		_init : vita.noop,
		//设置options
		_setOptions : function(options){
			for(var key in options){
				this._setOption(key,options[key]);
			}
			return this;
		},
		_setOption : function(key, value){
			this.options[ key ] = value;
		},	
		//销毁
		destroy : function(){
			//组件模块内部销毁前动作
			this._destroy();
			//删除绑定的事件侦听
			vita.event.removeListener(this);
			//删除实例
			this._removeInstance();
		},
		_destroy : vita.noop
	};
})(window);
/**
 * @author yangyj
 * @desc widget.ui.js ui组件类，继承widget.base.js
 * @depends core.js , widget.base.js
 */
(function(window){
    "use strict";
	//如果vita为空，或者vita下已经生成Widget节点，则不再初始化
	var vita = window.vita;
	if (!vita || (vita.Widget ? vita.Widget.ui : true)){
		return;
	}
	//ui类
	vita.Widget.ui = function(){};
	vita.self("extend",vita.Widget.ui.prototype,new vita.Widget(false),{
		//单例模式
		// get singleton(){
		// 	return false;
		// },
        singleton : false,
		options : {
			renderTo : null
		},
		template : "",
		//创建widget
		_createWidget : function(options){
			//选项合并
			this.options = vita.self("extend", true, {}, this.options, options);
			//全局引用
			this.global = vita.self("extend", true, {}, this.global);
			//创建ui元素
			if(!this.element){
				this.element = this._create();
			}
			//初始化ui元素事件
			this._initEvent();
			//如果有指定渲染位置
			var renderTo = this.options.renderTo;
			if(renderTo){
				if(vita.self("isDomObj",renderTo)){
					renderTo = $(renderTo);
				}
				renderTo.append(this.element);
			}
			//初始化
			this._init();
			//打入ui元素打标签
			if(this._isJqueryObj()){
				this.element.attr({"data-vid":this.vid,"data-widgetFullName":this.widgetFullName});
			}else if(this._isDomObj()){
				this.element.setAttribute("data-vid",this.vid);
				this.element.setAttribute("data-widgetFullName",this.widgetFullName);
			}
			//插件初始化完成
			this.isComplete = true;
		},
		//控件
		element : null,
		//创建插件//让插件自行实现
		_create : vita.noop,
		//初始化事件
		_initEvent : vita.noop,
		//销毁
		destroy : function(){
			//组件模块内部销毁前动作
			this._destroy();
			//删除绑定的事件侦听
			vita.event.removeListener(this);
			//删除实例
			this._removeInstance();
			if(this._isJqueryObj()){
				this.element.remove();
			}else if(this._isDomObj()){
				this.element.parentNode.removeChild(this.element);
			}
		},
		_isJqueryObj : function(){
			return vita.self("isJQueryObj",this.element);
		},
		_isDomObj : function(){
			return vita.self("isDomObj",this.element);
		},
        getElement : function(){
            return this.element;
        },
        //事件绑定
        bind : function(types,selector,data,fn){
            //这里调用了jquery的on方法，自己写太累了。。。如果element返回的不是jqeury对象，表用。。。
            this.element.on(types,selector,data,fn);
            return this;
        }
	});
})(window);
/**
 * @author yangyj
 * @desc widget.js 插件工厂
 * @depends core.js
 */
(function(window){
    "use strict";
    //如果vita为空，或者vita下已经生成widget节点，则不再初始化
	var vita = window.vita;
	if (!vita || vita.widget){
		return;
	}
	//插件缓存{widgetName : function(option)} //实例缓存{widgetName:{vid:obj}} //模块缓存{name:obj} //插件唯一标识
	var wCache = {}, iCache = {},  mCache = {}, vid = 0;
    //不对外暴露的方法
    var widget = {
        //注册
        register : function(name,func){
            return wCache[name] = func;
        },
        //取消注册
        unregister : function(name){
            delete wCache[name];
        },
        //获取组件类
        getWidget : function(name){
            return wCache[name];
        },
        //获取实例
        getInstance : function(name,vid){
            var m = iCache[name];
            return m ? (vid ? m[vid] : null) : null;
        },
        //设置实例
        setInstance : function(name,vid,elem){
            var m = iCache[name];
            if(!m){
                m = iCache[name] = {};
            }
            m[vid] = elem;
        },
        //删除实例
        removeInstance : function(name,vid){
            var m = iCache[name];
            if(m){
                if(vid){
                    delete m[vid];
                }else{
                    delete iCache[name];
                }
            }
        },
        //获取模块
        getModule : function(name){
            return mCache[name];
        },
        //缓存模块
        setModule : function(name, obj){
            return mCache[name] = obj;
        },
        //删除模块
        removeModule : function(name){
            if(name){
                delete mCache[name];
            }
        },
        //通用实例化方法
        new : function(name,options,target){
            var w = widget.getWidget(name), inst;
            if(w){
                inst = new w(options || {},target);
                //new以后，要缓存实例
                widget.setInstance(name,inst.vid,inst);
                return inst;
            }else{
                return null;
            }
        },
        //封装，隐藏属性和私有方法
        package : function(widget){
            var proxy = function(obj){
                var returnValue = {}, prototype = obj.constructor.prototype, pt;
                for(pt in prototype){
                    if(vita.self("isFunction",prototype[pt]) && pt.charAt(0) != "_" && pt != "require"){
                        //只开放组件的非_开头的函数（私有函数）和非require函数（组件请求函数）
                        returnValue[pt] = (function(){
                            var method = pt;
                            return function(){
                                return obj[method].apply(obj,arguments);
                            }
                        })();
                    }
                }
                return returnValue;
            };
            return proxy(widget);
        },
        //创建jquery插件//TODO
        toJquery : function(widgetName){
            if(!!window.jQuery){
                //jquery方法扩展
                jQuery.fn[widgetName] = function(options){
                    //设置或者初始化options
                    options = options || {};
                    //如果jquery对象长度为0，则新建一个插件，并返回其元素
                    if(this.length == 0){
                        return widget.new(widgetName,options).getElement();
                    }
                    //////
                    var returnValue = this, isMethodCall = typeof options === "string", args = Array.prototype.slice.call(arguments,1);
                    this.each(function(){
                        var $this = window.jQuery(this), instance = vita.widget.self("getInstance", widgetName, $this.attr("data-vid"));
                        if(!instance){
                            //新建插件
                            widget.new(widgetName,options,$this);
                        }else{
                            if(isMethodCall){
                                //方法调用//_开头的私有方法不允许外部调用
                                if(options.charAt(0) !== "_" && vita.self("isFunction",instance[options])){
                                    var methodValue = instance[options].apply(instance, args);
                                    if(methodValue !== instance && methodValue !== undefined){
                                        returnValue = methodValue && methodValue.jquery ? returnValue.pushStack(methodValue.get()) : methodValue;
                                        return false;
                                    }
                                }
                            }else{
                                //重设options
                                instance._setOptions(options)._init();
                            }
                        }
                    });
                    return returnValue;
                };
            }
        },
        //模块化//TODO
        toModule : function(name){
            if(typeof define === "function"){
                var func = function(require, exports, module){
                    var constructor = widget.getWidget(name);
                    constructor.prototype.require = require;
                    if(constructor.prototype.singleton){
                        //单例模式
                        var obj = widget.new(name);
                        module.exports = widget.package(obj);
                    }else{
                        //多例模式
                        exports.new = function(options){
                            var obj = widget.new(name,options);
                            return widget.package(obj);
                        };
                    }

                }
                //注册//暂时不区分amd还是cmd或者其他//暂时无差别
                define(name,[],func);
            }
        }
    };
	//构建器
	vita.widget = function(name, base, prototype){
		//必须有模块名称
		if(!name || !vita.self("isString",name)){
            throw new Error("创建组件异常：组件名为空或者不是字符串，组件名为（"+name+"）");
			return false;
		}
		var namespace, widgetName, widgetFullName, constructor, basePrototype;
		//处理模块名称和命名空间
        var analysisName = name.split(".");
		if(analysisName.length == 1){
			namespace = "";
			widgetName = name;
		}else{
			//带有命名空间
			namespace = analysisName[0];
			widgetName = analysisName[1];
		}
		widgetFullName = vita.name + "-" + widgetName;
		//调整入参
		if(vita.self("type", base) === "undefined"){
			prototype = {};
			base = namespace;
		}else if(vita.self("type", prototype) === "undefined"){
			prototype = base;
			base = namespace;
		}
        //寻找基类
        if(vita.self("isString", base)){
            //字符串
            if(base == ""){
                base = vita.Widget;
            }else{
                if(vita.Widget[base]){
                    base = vita.Widget[base];
                }else if(wCache[base]){
                    base = wCache[base];
                }else{
                    base = function(){};
                }
            }
        }else if(vita.self("isFunction", base)){
        }else{
            base = function(){};
        }
		//创建构造函数
		constructor = function(options,target){
            if(options != false){
                this.vid = ++vid;
                if(target){
                    this.element = target;
                }
                this._createWidget(options || {});
            }
		};
        //基类
        basePrototype = new base(false);
		vita.self("extend",constructor.prototype, basePrototype, {
			constructor: constructor,
			widgetName: widgetName,
            getWidgetName : function () {
                return this.widgetName;
            },
			widgetFullName: widgetFullName,
            version : vita.version,
            require : vita.widget.require,
            _removeInstance : function(){
                widget.removeInstance(this.widgetName,this.vid);
            },
            super : base.prototype
		},prototype);
        //组件注册
        widget.register(widgetName,constructor);
        //模块化
		widget.toModule(widgetName);
		//创建jquery插件//ui类才需要
        if(typeof constructor.prototype.element != "undefined"){
            widget.toJquery(widgetName);
        }
	};
    //模块请求
    vita.widget.require = function(name){
        //jquery特殊处理
        if(name == "jquery"){
            return window.jQuery;
        }
        //underscore特殊处理
        if(name == "underscore"){
            return window._;
        }
        //已被vita模块化
        var _module = widget.getModule(name);
        if(_module){
            return _module;
        }
        /**vita模块化**/
        var _class = widget.getWidget(name);
        if(_class){
            var newModule;
            if(_class.prototype.singleton){
                //单例模式
                var tmp = widget.new(name);
                newModule = widget.package(tmp);
            }else{
                //多例模式
                newModule = {
                    new : function(options){
                        var tmp = widget.new(name,options);
                        return widget.package(tmp);
                    }
                };
            }
            widget.setModule(name,newModule);
            return newModule;
        }else{
            return null;
        }
    };
    //删除模块
    vita.widget.remove = function(obj){
        obj.destroy();
    };
    //组件注册
    vita.widget.register = function(name, func, forJquery){
        if(func && func.prototype){
            //当组件没有指明组件名时，将注册名作为组件名
            func.prototype.widgetName = name;
            func.prototype.widgetFullName = vita.name + "-" + name;
        }
        //注册组件
        widget.register(name, func);
        //生成模块
        widget.toModule(name);
        if(forJquery){
            //生成jquery插件
            widget.toJquery(name);
        }
    };
    //组件解除注册
    vita.widget.unregister = function(name){
        widget.unregister(name);
    };
    //用来调用不公开的方法，主要调试查问题时使用
    vita.widget.self = function(){
        if(arguments && arguments.length > 0){
            var handle = arguments[0], params = Array.prototype.slice.call(arguments,1);
            if(vita.self("type",widget[handle]) === "function"){
                //如果是函数
                return widget[handle].apply(vita.widget,params);
            }else{
                //否则当作属性返回
                return widget[handle];
            }
        }
        return vita.widget;//没有入参就返回vita.widget对象
    };
})(window);
/**
 * @author yangyj
 * @desc modular.js 模块化
 * @depends core.js，widget.js(如果使用requirejs或者seajs,widget可以不依赖)
 */
(function(window){
    "use strict";
    //如果vita为空，或者vita下已经生成modular节点，则不再初始化
	var vita = window.vita;
	if (!vita || vita.modular){
		return;
	}
    //模块缓存 //当前使用的模块化工具
    var cache = {}, modularity = "vita";
    //不公开的模块化方法
    var modular = {
        //vita.modular初始化方法
        init : function(paths,callback){
            //如果没有paths，无法处理
            if(!paths){
                return false;
            }
            var srcs = vita.self("isArray", paths) ? paths : [paths] , loadedModules = [];
            var toDeal = function(){
                if(srcs.length > 0){
                    var src = srcs.shift();
                    if(cache[src]){
                        toDeal();
                    }else{
                        //还未加载过的路径
                        modular.load(src, function(m){
                            loadedModules.push(vita.widget.require(m));
                            cache[src] = true;
                            toDeal();
                        });
                    }
                }else{
                    callback.apply(this,loadedModules);
                }
            };
            toDeal();
        },
        //模块加载
        load : function(path,callback){
            var moduleName = modular.getModuleName(path),
                head = document.getElementsByTagName("head")[0],
                script = document.createElement("script");
            script.id = "vita.modular." + moduleName;
            script.type = "text/javascript";
            script.src = modular.perfectPath(path);
            var onload = function(){
                callback(moduleName);
            };
            //判断是否支持onload事件
            if("onload" in script){
                script.onload = onload;
            }else{
                script.onreadystatechange = function(){
                    if(/loaded|complete/.test(script.readyState)){
                        onload();
                    }
                }
            }
            //开始加载
            head.appendChild(script);
        },
        //获取模块名称
        getModuleName : function(path){
            var start = path.lastIndexOf("/") + 1 , end = path.lastIndexOf(".js");
            end = end > 0 ? end : path.length;
            return path.substring(start,end);
        },
        //补充js扩展名
        perfectPath : function(path){
            var index = path.lastIndexOf(".js");
            if(index == -1 || index != path.length - 3){
                path += ".js";
            }
            return path;
        }
    };
    //统一模块封装，支持vita、seajs、reqiurejs
    vita.modular = {
        //模块初始化
        init : function(options){
            if(!options.index || (vita.self("isArray",options.index) && options.index.length == 0)){
                //如果没有有效index则不能处理，直接返回
                return false;
            }
            var indexjs = options.index, callback = options.callback, dependents = [];
            if(options.dependents){
                dependents = options.dependents;    
            }
            //判断当前模块化情况
            if(typeof seajs != "undefined"){
                //seajs模块化
                modularity = "seajs";
                seajs.use(dependents,function(){
                    seajs.use(indexjs,function(){
                        if(callback){
                            callback.apply(this,arguments);
                        }
                    });
                });
            }else if(typeof require != "undefined"){
                //requirejs模块化
                modularity = "requirejs";
                //TODO，后面再研究
                /**
                require(indexjs, function() {
                    callback.apply(this,arguments);
                });
                **/
            }else{
                //vita一般处理
                modular.init(dependents,function(){
                    modular.init(indexjs,function(){
                        if(callback){
                            callback.apply(this,arguments);
                        }
                    });            
                });
            }            
        },
        //当前模块化工具
        // get modularity(){
        //     return modularity;
        // },
        getModularity : function () {
            return modularity;
        }
    };
})(window);
/**
 * @author yangyj
 * @desc debug.js 调试
 * @depends core.js
 */
(function (window) {
    "use strict";
    //如果vita为空，或者vita下已经生成debug节点，则不再初始化
    var vita = window.vita;
    if (!vita || vita.debug){
        return;
    }

    var debug = {
        convert : function (namespaces) {
            if(vita.isDomObj(namespaces)){
                namespaces = $(namespaces);
            }
            if(vita.isJQueryObj(namespaces)){
                var widgetfullname = namespaces.attr("data-widgetfullname");
                if(widgetfullname){
                    namespaces = vita.widget.self("getInstance", widgetfullname.split("-")[1], namespaces.attr("data-vid"));
                }
            }
            return namespaces;
        }
    };

    vita.debug = {
        debugger : function (pointcut, namespaces) {
            return vita.aop.before(pointcut, function () {
                debugger;
            }, debug.convert(namespaces));
        },
        trace : function (pointcut, namespaces) {
            return vita.aop.before(pointcut, function () {
                console.trace();
            }, debug.convert(namespaces));
        }
    };

})(window);
/**
 * @author yangyj
 * @desc storage.js 本地存储
 * @depends core.js
 */
(function (window) {
    "use strict";
    //如果vita为空，或者vita下已经生成storage节点，则不再初始化
    var vita = window.vita;
    if (!vita || vita.storage){
        return;
    }
    vita.storage = {
        setItem : function (key, value) {
            localStorage.setItem(key, value);
        },
        getItem : function (key) {
            localStorage.getItem(key);
        },
        removeItem : function (key) {
            localStorage.removeItem(key);
        },
        clear : function () {
            localStorage.clear();
        }
    };
})(window);